#region Copyright & License

//
// Copyright 2001-2005 The Apache Software Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#endregion

// .NET Compact Framework 1.0 has no support for reading assembly attributes
#if !NETCF

using System;
using System.IO;
using System.Reflection;
using log4net.Repository;
using log4net.Repository.Hierarchy;
using log4net.Util;

namespace log4net.Config {
  /// <summary>
  /// Assembly level attribute to configure the <see cref="XmlConfigurator"/>.
  /// </summary>
  /// <remarks>
  /// <para>
  /// This attribute may only be used at the assembly scope and can only
  /// be used once per assembly.
  /// </para>
  /// <para>
  /// Use this attribute to configure the <see cref="XmlConfigurator"/>
  /// without calling one of the <see cref="XmlConfigurator.Configure()"/>
  /// methods.
  /// </para>
  /// <para>
  /// If neither of the <see cref="ConfigFile"/> or <see cref="ConfigFileExtension"/>
  /// properties are set the configuration is loaded from the application's .config file.
  /// If set the <see cref="ConfigFile"/> property takes priority over the
  /// <see cref="ConfigFileExtension"/> property. The <see cref="ConfigFile"/> property
  /// specifies a path to a file to load the config from. The path is relative to the
  /// application's base directory; <see cref="AppDomain.BaseDirectory"/>.
  /// The <see cref="ConfigFileExtension"/> property is used as a postfix to the assembly file name.
  /// The config file must be located in the  application's base directory; <see cref="AppDomain.BaseDirectory"/>.
  /// For example in a console application setting the <see cref="ConfigFileExtension"/> to
  /// <c>config</c> has the same effect as not specifying the <see cref="ConfigFile"/> or 
  /// <see cref="ConfigFileExtension"/> properties.
  /// </para>
  /// <para>
  /// The <see cref="Watch"/> property can be set to cause the <see cref="XmlConfigurator"/>
  /// to watch the configuration file for changes.
  /// </para>
  /// <note>
  /// <para>
  /// Log4net will only look for assembly level configuration attributes once.
  /// When using the log4net assembly level attributes to control the configuration 
  /// of log4net you must ensure that the first call to any of the 
  /// <see cref="log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration
  /// attributes. 
  /// </para>
  /// <para>
  /// If you cannot guarantee the order in which log4net calls will be made from 
  /// different assemblies you must use programmatic configuration instead, i.e.
  /// call the <see cref="XmlConfigurator.Configure()"/> method directly.
  /// </para>
  /// </note>
  /// </remarks>
  /// <author>Nicko Cadell</author>
  /// <author>Gert Driesen</author>
  [AttributeUsage(AttributeTargets.Assembly)]
  [Serializable]
  public /*sealed*/ class XmlConfiguratorAttribute : ConfiguratorAttribute {
    //
    // Class is not sealed because DOMConfiguratorAttribute extends it while it is obsoleted
    // 

    /// <summary>
    /// Default constructor
    /// </summary>
    /// <remarks>
    /// <para>
    /// Default constructor
    /// </para>
    /// </remarks>
    public XmlConfiguratorAttribute() : base(0) /* configurator priority 0 */ {}

    #region Public Instance Properties

    /// <summary>
    /// Gets or sets the filename of the configuration file.
    /// </summary>
    /// <value>
    /// The filename of the configuration file.
    /// </value>
    /// <remarks>
    /// <para>
    /// If specified, this is the name of the configuration file to use with
    /// the <see cref="XmlConfigurator"/>. This file path is relative to the
    /// <b>application base</b> directory (<see cref="AppDomain.BaseDirectory"/>).
    /// </para>
    /// <para>
    /// The <see cref="ConfigFile"/> takes priority over the <see cref="ConfigFileExtension"/>.
    /// </para>
    /// </remarks>
    public string ConfigFile {
      get { return m_configFile; }
      set { m_configFile = value; }
    }

    /// <summary>
    /// Gets or sets the extension of the configuration file.
    /// </summary>
    /// <value>
    /// The extension of the configuration file.
    /// </value>
    /// <remarks>
    /// <para>
    /// If specified this is the extension for the configuration file.
    /// The path to the config file is built by using the <b>application 
    /// base</b> directory (<see cref="AppDomain.BaseDirectory"/>),
    /// the <b>assembly file name</b> and the config file extension.
    /// </para>
    /// <para>
    /// If the <see cref="ConfigFileExtension"/> is set to <c>MyExt</c> then
    /// possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or
    /// <c>MyClassLibrary.dll.MyExt</c>.
    /// </para>
    /// <para>
    /// The <see cref="ConfigFile"/> takes priority over the <see cref="ConfigFileExtension"/>.
    /// </para>
    /// </remarks>
    public string ConfigFileExtension {
      get { return m_configFileExtension; }
      set { m_configFileExtension = value; }
    }

    /// <summary>
    /// Gets or sets a value indicating whether to watch the configuration file.
    /// </summary>
    /// <value>
    /// <c>true</c> if the configuration should be watched, <c>false</c> otherwise.
    /// </value>
    /// <remarks>
    /// <para>
    /// If this flag is specified and set to <c>true</c> then the framework
    /// will watch the configuration file and will reload the config each time 
    /// the file is modified.
    /// </para>
    /// <para>
    /// The config file can only be watched if it is loaded from local disk.
    /// In a No-Touch (Smart Client) deployment where the application is downloaded
    /// from a web server the config file may not reside on the local disk
    /// and therefore it may not be able to watch it.
    /// </para>
    /// <note>
    /// Watching configuration is not supported on the SSCLI.
    /// </note>
    /// </remarks>
    public bool Watch {
      get { return m_configureAndWatch; }
      set { m_configureAndWatch = value; }
    }

    #endregion Public Instance Properties

    #region Override ConfiguratorAttribute

    /// <summary>
    /// Configures the <see cref="ILoggerRepository"/> for the specified assembly.
    /// </summary>
    /// <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
    /// <param name="targetRepository">The repository to configure.</param>
    /// <remarks>
    /// <para>
    /// Configure the repository using the <see cref="XmlConfigurator"/>.
    /// The <paramref name="targetRepository"/> specified must extend the <see cref="Hierarchy"/>
    /// class otherwise the <see cref="XmlConfigurator"/> will not be able to
    /// configure it.
    /// </para>
    /// </remarks>
    /// <exception cref="ArgumentOutOfRangeException">The <paramref name="repository" /> does not extend <see cref="Hierarchy"/>.</exception>
    public override void Configure(Assembly sourceAssembly, ILoggerRepository targetRepository) {
      string applicationBaseDirectory = null;
      try {
        applicationBaseDirectory = SystemInfo.ApplicationBaseDirectory;
      } catch {
        // Ignore this exception because it is only thrown when ApplicationBaseDirectory is a file
        // and the application does not have PathDiscovery permission
      }

      if (applicationBaseDirectory == null || (new Uri(applicationBaseDirectory)).IsFile)
        ConfigureFromFile(sourceAssembly, targetRepository);
      else
        ConfigureFromUri(sourceAssembly, targetRepository);
    }

    #endregion

    /// <summary>
    /// Attempt to load configuration from the local file system
    /// </summary>
    /// <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
    /// <param name="targetRepository">The repository to configure.</param>
    void ConfigureFromFile(Assembly sourceAssembly, ILoggerRepository targetRepository) {
      // Work out the full path to the config file
      string fullPath2ConfigFile = null;

      // Select the config file
      if (m_configFile == null || m_configFile.Length == 0)
        if (m_configFileExtension == null || m_configFileExtension.Length == 0)
          // Use the default .config file for the AppDomain
          try {
            fullPath2ConfigFile = SystemInfo.ConfigurationFileLocation;
          } catch (Exception ex) {
            LogLog.Error(
              "XmlConfiguratorAttribute: Exception getting ConfigurationFileLocation. Must be able to resolve ConfigurationFileLocation when ConfigFile and ConfigFileExtension properties are not set.",
              ex);
          }
        else {
          // Force the extension to start with a '.'
          if (m_configFileExtension[0] != '.')
            m_configFileExtension = "." + m_configFileExtension;

          string applicationBaseDirectory = null;
          try {
            applicationBaseDirectory = SystemInfo.ApplicationBaseDirectory;
          } catch (Exception ex) {
            LogLog.Error(
              "XmlConfiguratorAttribute: Exception getting ApplicationBaseDirectory. Must be able to resolve ApplicationBaseDirectory and AssemblyFileName when ConfigFileExtension property is set.",
              ex);
          }

          if (applicationBaseDirectory != null)
            fullPath2ConfigFile = Path.Combine(applicationBaseDirectory,
                                               SystemInfo.AssemblyFileName(sourceAssembly) +
                                               m_configFileExtension);
        }
      else {
        string applicationBaseDirectory = null;
        try {
          applicationBaseDirectory = SystemInfo.ApplicationBaseDirectory;
        } catch (Exception ex) {
          LogLog.Warn(
            "XmlConfiguratorAttribute: Exception getting ApplicationBaseDirectory. ConfigFile property path [" +
            m_configFile + "] will be treated as an absolute path.", ex);
        }

        if (applicationBaseDirectory != null) // Just the base dir + the config file
          fullPath2ConfigFile = Path.Combine(applicationBaseDirectory, m_configFile);
        else
          fullPath2ConfigFile = m_configFile;
      }

      if (fullPath2ConfigFile != null)
        ConfigureFromFile(targetRepository, new FileInfo(fullPath2ConfigFile));
    }

    /// <summary>
    /// Configure the specified repository using a <see cref="FileInfo"/>
    /// </summary>
    /// <param name="targetRepository">The repository to configure.</param>
    /// <param name="configFile">the FileInfo pointing to the config file</param>
    void ConfigureFromFile(ILoggerRepository targetRepository, FileInfo configFile) {
#if (SSCLI)
			if (m_configureAndWatch)
			{
				LogLog.Warn("XmlConfiguratorAttribute: Unable to watch config file not supported on SSCLI");
			}
			XmlConfigurator.Configure(targetRepository, configFile);
#else
      // Do we configure just once or do we configure and then watch?
      if (m_configureAndWatch)
        XmlConfigurator.ConfigureAndWatch(targetRepository, configFile);
      else
        XmlConfigurator.Configure(targetRepository, configFile);
#endif
    }

    /// <summary>
    /// Attempt to load configuration from a URI
    /// </summary>
    /// <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
    /// <param name="targetRepository">The repository to configure.</param>
    void ConfigureFromUri(Assembly sourceAssembly, ILoggerRepository targetRepository) {
      // Work out the full path to the config file
      Uri fullPath2ConfigFile = null;

      // Select the config file
      if (m_configFile == null || m_configFile.Length == 0)
        if (m_configFileExtension == null || m_configFileExtension.Length == 0) {
          string systemConfigFilePath = null;
          try {
            systemConfigFilePath = SystemInfo.ConfigurationFileLocation;
          } catch (Exception ex) {
            LogLog.Error(
              "XmlConfiguratorAttribute: Exception getting ConfigurationFileLocation. Must be able to resolve ConfigurationFileLocation when ConfigFile and ConfigFileExtension properties are not set.",
              ex);
          }

          if (systemConfigFilePath != null) {
            var systemConfigFileUri = new Uri(systemConfigFilePath);

            // Use the default .config file for the AppDomain
            fullPath2ConfigFile = systemConfigFileUri;
          }
        } else {
          // Force the extension to start with a '.'
          if (m_configFileExtension[0] != '.')
            m_configFileExtension = "." + m_configFileExtension;

          string systemConfigFilePath = null;
          try {
            systemConfigFilePath = SystemInfo.ConfigurationFileLocation;
          } catch (Exception ex) {
            LogLog.Error(
              "XmlConfiguratorAttribute: Exception getting ConfigurationFileLocation. Must be able to resolve ConfigurationFileLocation when the ConfigFile property are not set.",
              ex);
          }

          if (systemConfigFilePath != null) {
            var builder = new UriBuilder(new Uri(systemConfigFilePath));

            // Remove the current extension from the systemConfigFileUri path
            string path = builder.Path;
            int startOfExtension = path.LastIndexOf(".");
            if (startOfExtension >= 0)
              path = path.Substring(0, startOfExtension);
            path += m_configFileExtension;

            builder.Path = path;
            fullPath2ConfigFile = builder.Uri;
          }
        }
      else {
        string applicationBaseDirectory = null;
        try {
          applicationBaseDirectory = SystemInfo.ApplicationBaseDirectory;
        } catch (Exception ex) {
          LogLog.Warn(
            "XmlConfiguratorAttribute: Exception getting ApplicationBaseDirectory. ConfigFile property path [" +
            m_configFile + "] will be treated as an absolute URI.", ex);
        }

        if (applicationBaseDirectory != null) // Just the base dir + the config file
          fullPath2ConfigFile = new Uri(new Uri(applicationBaseDirectory), m_configFile);
        else
          fullPath2ConfigFile = new Uri(m_configFile);
      }

      if (fullPath2ConfigFile != null)
        if (fullPath2ConfigFile.IsFile)
          // The m_configFile could be an absolute local path, therefore we have to be
          // prepared to switch back to using FileInfos here
          ConfigureFromFile(targetRepository, new FileInfo(fullPath2ConfigFile.LocalPath));
        else {
          if (m_configureAndWatch)
            LogLog.Warn("XmlConfiguratorAttribute: Unable to watch config file loaded from a URI");
          XmlConfigurator.Configure(targetRepository, fullPath2ConfigFile);
        }
    }

    #region Private Instance Fields

    string m_configFile;
    string m_configFileExtension;
    bool m_configureAndWatch;

    #endregion Private Instance Fields
  }
}

#endif // !NETCF